/**
 * 错题服务工具类
 * 用于与后端错题系统交互
 */

const { http } = require('./http');
const { getUserInfo } = require('./storageUtil');

class WrongQuestionService {
  constructor() {
    this.baseUrl = '/wjq/wrongquestion';
  }

  /**
   * 获取错题统计数量
   */
  async getWrongQuestionCount(userId) {
    try {
      // 使用现有的list接口，通过分页参数获取总数
      const res = await http.get(`${this.baseUrl}/list`, { 
        userId: userId,
        pageNum: 1,
        pageSize: 1
      });
      console.log('错题数量接口返回:', res);
      return res.total || 0;
    } catch (error) {
      console.error('获取错题数量失败:', error);
      return 0;
    }
  }

  /**
   * 根据科目获取错题数量
   */
  async getWrongQuestionCountBySubject(userId, subjectId) {
    try {
      // 获取所有错题，然后按科目筛选统计
      const res = await http.get(`${this.baseUrl}/list`, { 
        userId: userId,
        pageNum: 1,
        pageSize: 1000 // 获取足够多的数据来统计
      });
      
      if (res.rows && res.rows.length > 0) {
        let count = 0;
        res.rows.forEach(item => {
          let itemSubjectId = item.subjectId || item.questionBank?.subjectId;
          if (!itemSubjectId) {
            itemSubjectId = this.assignSubjectByBankId(item.questionBankId, item.questionBank?.name);
          }
          
          if (itemSubjectId === subjectId) {
            count++;
          }
        });
        return count;
      }
      return 0;
    } catch (error) {
      console.error('获取科目错题数量失败:', error);
      return 0;
    }
  }

  /**
   * 获取错题列表（按题库分类）
   */
  async getWrongQuestionsByBank(params) {
    try {
      const res = await http.get(`${this.baseUrl}/list`, params);
      return res.rows || [];
    } catch (error) {
      console.error('获取按题库错题列表失败:', error);
      return [];
    }
  }

  /**
   * 获取所有错题列表
   */
  async getAllWrongQuestions(params) {
    try {
      const res = await http.get(`${this.baseUrl}/list`, params);
      return res.rows || [];
    } catch (error) {
      console.error('获取所有错题列表失败:', error);
      return [];
    }
  }

  /**
   * 删除错题
   */
  async deleteWrongQuestions(ids) {
    try {
      const res = await http.delete(`${this.baseUrl}/${ids.join(',')}`);
      return res.code === 200;
    } catch (error) {
      console.error('删除错题失败:', error);
      return false;
    }
  }

  /**
   * 添加错题记录
   */
  async addWrongQuestion(data) {
    try {
      const res = await http.post(this.baseUrl, data);
      console.log('添加错题记录返回:', res);
      
      if (res.code === 200) {
        return true;
      } else {
        throw new Error(res.message || '添加错题失败');
      }
    } catch (error) {
      console.error('添加错题记录失败:', error);
      throw error;
    }
  }

  /**
   * 获取题库列表（从错题中统计）
   */
  async getQuestionBanks() {
    try {
      // 先获取所有错题，然后按题库分组统计
      const res = await http.get(`${this.baseUrl}/list`, { 
        pageNum: 1,
        pageSize: 1000 // 获取足够多的数据来统计
      });
      console.log('题库列表接口返回:', res);
      
      if (res.rows && res.rows.length > 0) {
        // 前端统计题库
        const bankMap = new Map();
        res.rows.forEach(item => {
          const bankId = item.questionBankId;
          const bankName = item.questionBank?.name || `题库${bankId}`;
          
          if (!bankMap.has(bankId)) {
            bankMap.set(bankId, {
              id: bankId,
              name: bankName,
              mistakeCount: 0
            });
          }
          bankMap.get(bankId).mistakeCount++;
        });
        
        return Array.from(bankMap.values());
      }
      
      return [];
    } catch (error) {
      console.error('获取题库列表失败:', error);
      return [];
    }
  }

  /**
   * 获取错题章节统计
   */
  async getWrongQuestionChapters(params) {
    try {
      // 使用现有的list接口，获取错题数据
      const res = await http.get(`${this.baseUrl}/list`, params);
      console.log('错题章节统计接口返回:', res);
      
      if (res.rows && res.rows.length > 0) {
        // 前端按章节分组统计
        const chapterMap = new Map();
        res.rows.forEach(item => {
          // 这里假设错题有章节信息，如果没有则使用题库信息
          const chapterId = item.chapterId || item.questionBankId;
          const chapterName = item.chapterName || item.questionBank?.name || `第${chapterId}章`;
          const bankName = item.questionBank?.name || '题库分类';
          
          // 智能分配科目
          const subjectId = this.assignSubjectByBankId(item.questionBankId, item.questionBank?.name);
          const subjectName = this.getSubjectName(subjectId);
          
          if (!chapterMap.has(chapterId)) {
            chapterMap.set(chapterId, {
              id: chapterId,
              chapterId: chapterId,
              chapterName: chapterName,
              bankName: bankName,
              subjectId: subjectId,
              subjectName: subjectName,
              mistakeCount: 0,
              coverImage: item.question?.coverImage || this.getSubjectIcon(subjectId)
            });
          }
          chapterMap.get(chapterId).mistakeCount++;
        });
        
        return Array.from(chapterMap.values());
      }
      
      return [];
    } catch (error) {
      console.error('获取错题章节统计失败:', error);
      return [];
    }
  }

  /**
   * 获取科目列表
   */
  async getSubjects() {
    try {
      // 这里可以调用后端的科目接口，如果没有则返回默认科目
      // const res = await http.get('/system/subject/list');
      // return res.rows || [];
      
      // 暂时返回默认科目列表，ID要与数据库保持一致
      return [
        { id: 1, name: '物理', icon: '/images/wuli.png' },
        { id: 2, name: '科学', icon: '/images/kexue.png' },
        { id: 3, name: '化学', icon: '/images/huaxue.png' },
        { id: 4, name: '生物', icon: '/images/shengwu.png' },
        { id: 5, name: '数学', icon: '/images/shuxue.png' },
        { id: 6, name: '政治', icon: '/images/zhengzhi.png' },
        { id: 7, name: '文学', icon: '/images/wenxue.png' }
      ];
    } catch (error) {
      console.error('获取科目列表失败:', error);
      return [];
    }
  }

  /**
   * 按科目获取错题章节统计
   */
  async getWrongQuestionChaptersBySubject(params) {
    try {
      // 使用现有的list接口，获取错题数据
      const res = await http.get(`${this.baseUrl}/list`, params);
      console.log('按科目错题章节统计接口返回:', res);
      
      if (res.rows && res.rows.length > 0) {
        // 前端按科目和章节分组统计
        const chapterMap = new Map();
        const { subjectId: targetSubjectId } = params; // 获取目标科目ID
        
        res.rows.forEach(item => {
          // 获取题目的科目ID
          let itemSubjectId = item.subjectId || item.questionBank?.subjectId;
          if (!itemSubjectId) {
            // 如果没有科目信息，根据题库ID或其他逻辑来分配
            itemSubjectId = this.assignSubjectByBankId(item.questionBankId, item.questionBank?.name);
          }
          
          // 如果指定了科目ID，则只处理该科目的错题
          if (targetSubjectId && targetSubjectId !== 0 && itemSubjectId !== targetSubjectId) {
            return; // 跳过不匹配的科目
          }
          
          // 这里假设错题有科目和章节信息
          const chapterId = item.chapterId || item.questionBankId;
          const chapterName = item.chapterName || item.questionBank?.name || `第${chapterId}章`;
          
          const subjectName = this.getSubjectName(itemSubjectId);
          
          if (!chapterMap.has(chapterId)) {
            chapterMap.set(chapterId, {
              id: chapterId,
              chapterId: chapterId,
              chapterName: chapterName,
              subjectId: itemSubjectId,
              subjectName: subjectName,
              mistakeCount: 0,
              coverImage: item.question?.coverImage || this.getSubjectIcon(itemSubjectId)
            });
          }
          chapterMap.get(chapterId).mistakeCount++;
        });
        
        return Array.from(chapterMap.values());
      }
      
      return [];
    } catch (error) {
      console.error('按科目获取错题章节统计失败:', error);
      return [];
    }
  }

  /**
   * 根据科目ID获取科目名称
   */
  getSubjectName(subjectId) {
    const subjectMap = {
      1: '物理',
      2: '科学',
      3: '化学',
      4: '生物',
      5: '数学',
      6: '政治',
      7: '文学'
    };
    return subjectMap[subjectId] || '未知科目';
  }

  /**
   * 根据科目ID获取科目图标
   */
  getSubjectIcon(subjectId) {
    const iconMap = {
      1: '/images/wuli.png',
      2: '/images/kexue.png',
      3: '/images/huaxue.png',
      4: '/images/shengwu.png',
      5: '/images/shuxue.png',
      6: '/images/zhengzhi.png',
      7: '/images/wenxue.png'
    };
    return iconMap[subjectId] || '/images/题库.png';
  }

  /**
   * 根据题库ID或名称智能分配科目
   */
  assignSubjectByBankId(bankId, bankName) {
    if (!bankId && !bankName) {
      // 如果都没有，返回默认科目
      return 5; // 默认数学
    }

    // 根据题库名称关键词分配科目（优先级最高）
    if (bankName) {
      const name = bankName.toLowerCase();
      if (name.includes('物理') || name.includes('physics') || name.includes('力学') || name.includes('电学')) {
        return 1; // 物理
      } else if (name.includes('科学') || name.includes('science') || name.includes('地球') || name.includes('环境')) {
        return 2; // 科学
      } else if (name.includes('化学') || name.includes('chemistry') || name.includes('有机') || name.includes('无机')) {
        return 3; // 化学
      } else if (name.includes('生物') || name.includes('biology') || name.includes('细胞') || name.includes('遗传')) {
        return 4; // 生物
      } else if (name.includes('数学') || name.includes('math') || name.includes('代数') || name.includes('几何')) {
        return 5; // 数学
      } else if (name.includes('政治') || name.includes('politics') || name.includes('马原') || name.includes('毛概')) {
        return 6; // 政治
      } else if (name.includes('语文') || name.includes('chinese') || name.includes('文学') || name.includes('文言')) {
        return 7; // 文学
      }
    }

    // 根据题库ID分配科目（使用固定的取模运算，确保一致性）
    if (bankId) {
      // 使用固定的种子值确保同一题库ID始终分配到同一科目
      const seed = Math.abs(bankId);
      return (seed % 7) + 1;
    }

    // 默认返回数学科目
    return 5;
  }

  /**
   * 测试方法：直接获取错题列表
   */
  async testWrongQuestionList() {
    try {
      const res = await http.get(`${this.baseUrl}/list`, {
        pageNum: 1,
        pageSize: 10
      });
      console.log('测试错题列表接口返回:', res);
      return res;
    } catch (error) {
      console.error('测试错题列表失败:', error);
      return null;
    }
  }
}

module.exports = new WrongQuestionService();